home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / version.pyo (.txt) < prev   
Python Compiled Bytecode  |  2005-10-18  |  7KB  |  204 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. """Provides classes to represent module version numbers (one class for
  5. each style of version numbering).  There are currently two such classes
  6. implemented: StrictVersion and LooseVersion.
  7.  
  8. Every version number class implements the following interface:
  9.   * the 'parse' method takes a string and parses it to some internal
  10.     representation; if the string is an invalid version number,
  11.     'parse' raises a ValueError exception
  12.   * the class constructor takes an optional string argument which,
  13.     if supplied, is passed to 'parse'
  14.   * __str__ reconstructs the string that was passed to 'parse' (or
  15.     an equivalent string -- ie. one that will generate an equivalent
  16.     version number instance)
  17.   * __repr__ generates Python code to recreate the version number instance
  18.   * __cmp__ compares the current instance with either another instance
  19.     of the same class or a string (which will be parsed to an instance
  20.     of the same class, thus must follow the same rules)
  21. """
  22. import string
  23. import re
  24. from types import StringType
  25.  
  26. class Version:
  27.     '''Abstract base class for version numbering classes.  Just provides
  28.     constructor (__init__) and reproducer (__repr__), because those
  29.     seem to be the same for all version numbering classes.
  30.     '''
  31.     
  32.     def __init__(self, vstring = None):
  33.         if vstring:
  34.             self.parse(vstring)
  35.         
  36.  
  37.     
  38.     def __repr__(self):
  39.         return "%s ('%s')" % (self.__class__.__name__, str(self))
  40.  
  41.  
  42.  
  43. class StrictVersion(Version):
  44.     '''Version numbering for anal retentives and software idealists.
  45.     Implements the standard interface for version number classes as
  46.     described above.  A version number consists of two or three
  47.     dot-separated numeric components, with an optional "pre-release" tag
  48.     on the end.  The pre-release tag consists of the letter \'a\' or \'b\'
  49.     followed by a number.  If the numeric components of two version
  50.     numbers are equal, then one with a pre-release tag will always
  51.     be deemed earlier (lesser) than one without.
  52.  
  53.     The following are valid version numbers (shown in the order that
  54.     would be obtained by sorting according to the supplied cmp function):
  55.  
  56.         0.4       0.4.0  (these two are equivalent)
  57.         0.4.1
  58.         0.5a1
  59.         0.5b3
  60.         0.5
  61.         0.9.6
  62.         1.0
  63.         1.0.4a3
  64.         1.0.4b1
  65.         1.0.4
  66.  
  67.     The following are examples of invalid version numbers:
  68.  
  69.         1
  70.         2.7.2.2
  71.         1.3.a4
  72.         1.3pl1
  73.         1.3c4
  74.  
  75.     The rationale for this version numbering system will be explained
  76.     in the distutils documentation.
  77.     '''
  78.     version_re = re.compile('^(\\d+) \\. (\\d+) (\\. (\\d+))? ([ab](\\d+))?$', re.VERBOSE)
  79.     
  80.     def parse(self, vstring):
  81.         match = self.version_re.match(vstring)
  82.         if not match:
  83.             raise ValueError, "invalid version number '%s'" % vstring
  84.         
  85.         (major, minor, patch, prerelease, prerelease_num) = match.group(1, 2, 4, 5, 6)
  86.         if patch:
  87.             self.version = tuple(map(string.atoi, [
  88.                 major,
  89.                 minor,
  90.                 patch]))
  91.         else:
  92.             self.version = tuple(map(string.atoi, [
  93.                 major,
  94.                 minor]) + [
  95.                 0])
  96.         if prerelease:
  97.             self.prerelease = (prerelease[0], string.atoi(prerelease_num))
  98.         else:
  99.             self.prerelease = None
  100.  
  101.     
  102.     def __str__(self):
  103.         if self.version[2] == 0:
  104.             vstring = string.join(map(str, self.version[0:2]), '.')
  105.         else:
  106.             vstring = string.join(map(str, self.version), '.')
  107.         if self.prerelease:
  108.             vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
  109.         
  110.         return vstring
  111.  
  112.     
  113.     def __cmp__(self, other):
  114.         if isinstance(other, StringType):
  115.             other = StrictVersion(other)
  116.         
  117.         compare = cmp(self.version, other.version)
  118.         if compare == 0:
  119.             if not (self.prerelease) and not (other.prerelease):
  120.                 return 0
  121.             elif self.prerelease and not (other.prerelease):
  122.                 return -1
  123.             elif not (self.prerelease) and other.prerelease:
  124.                 return 1
  125.             elif self.prerelease and other.prerelease:
  126.                 return cmp(self.prerelease, other.prerelease)
  127.             
  128.         else:
  129.             return compare
  130.  
  131.  
  132.  
  133. class LooseVersion(Version):
  134.     '''Version numbering for anarchists and software realists.
  135.     Implements the standard interface for version number classes as
  136.     described above.  A version number consists of a series of numbers,
  137.     separated by either periods or strings of letters.  When comparing
  138.     version numbers, the numeric components will be compared
  139.     numerically, and the alphabetic components lexically.  The following
  140.     are all valid version numbers, in no particular order:
  141.  
  142.         1.5.1
  143.         1.5.2b2
  144.         161
  145.         3.10a
  146.         8.02
  147.         3.4j
  148.         1996.07.12
  149.         3.2.pl0
  150.         3.1.1.6
  151.         2g6
  152.         11g
  153.         0.960923
  154.         2.2beta29
  155.         1.13++
  156.         5.5.kw
  157.         2.0b1pl0
  158.  
  159.     In fact, there is no such thing as an invalid version number under
  160.     this scheme; the rules for comparison are simple and predictable,
  161.     but may not always give the results you want (for some definition
  162.     of "want").
  163.     '''
  164.     component_re = re.compile('(\\d+ | [a-z]+ | \\.)', re.VERBOSE)
  165.     
  166.     def __init__(self, vstring = None):
  167.         if vstring:
  168.             self.parse(vstring)
  169.         
  170.  
  171.     
  172.     def parse(self, vstring):
  173.         self.vstring = vstring
  174.         components = filter((lambda x: if x:
  175. passx != '.'), self.component_re.split(vstring))
  176.         for i in range(len(components)):
  177.             
  178.             try:
  179.                 components[i] = int(components[i])
  180.             continue
  181.             except ValueError:
  182.                 continue
  183.             
  184.  
  185.         
  186.         self.version = components
  187.  
  188.     
  189.     def __str__(self):
  190.         return self.vstring
  191.  
  192.     
  193.     def __repr__(self):
  194.         return "LooseVersion ('%s')" % str(self)
  195.  
  196.     
  197.     def __cmp__(self, other):
  198.         if isinstance(other, StringType):
  199.             other = LooseVersion(other)
  200.         
  201.         return cmp(self.version, other.version)
  202.  
  203.  
  204.